/**********************************************************************************************/
/* FBL_MemPtr.h																				  */
/*                                                                       					  */
/* Copyright Paradigma, 1993-2006                                       					  */
/* All Rights Reserved.                                                 					  */
/**********************************************************************************************/

#ifndef _FBL_MemPtr_h 
	#define _FBL_MemPtr_h
#pragma once

#include <string.h> // memcpy


#include <VShared/FBL/publ/Headers/FBL_pre_header.h>


/**********************************************************************************************/
FBL_Begin_Namespace


/**********************************************************************************************/
template<class T> class MemPtr
{
	public://///////////////////////////////////////////////////////////////////////////////////

							MemPtr( ulong inSize = 0 ) : p( NULL )
							{ 
								Allocate( inSize );
							}

							MemPtr( const T* inData, ulong inSize )  : p( NULL )
							{ 
								Allocate( inSize );
								if( mSize )
								{
									memcpy(p, inData, sizeof(T) * mSize);
								}
							}

							~MemPtr( void )
							{ 
								if(p) delete [] p; 
							}


							operator T* (void) 				{ return p; }
							operator const T* (void) const 	{ return p; }
					
		const T*			begin( void ) const 			{ return p; }
		const T*			end( void ) const 				{ return p + mSize; }
				
		T*					begin( void ) 					{ return p; }
		T*					end( void ) 	 				{ return p + mSize; }
				
		T&					operator[]( ulong inIndex ) 	{ return p[inIndex]; }		

		void				FillWith(int ch)
							{
								memset(p, ch, (ulong)((sizeof(T) * mSize)));
							}

		ulong				get_Size(void) const throw()	{ return mSize; }
		void				put_Size( ulong inSize ) 
							{ 
								Allocate( inSize );
							}

		T*					Dismiss( void ) throw()
							{
								T* pT = p;
								mSize = 0;
								p = 0;
								return pT;
							}

	private:///////////////////////////////////////////////////////////////////////////////////

		void				Allocate( ulong inSize )
							{
								if( p != NULL )
								{
									delete [] p;
								}

								mSize = inSize;

								p = mSize ? new T[mSize] : NULL; 
							}


	private:///////////////////////////////////////////////////////////////////////////////////

		T* 					p;
		ulong 				mSize;
};


/**********************************************************************************************/
typedef MemPtr<char> CharPtr;


/**********************************************************************************************/
FBL_End_Namespace

#include <VShared/FBL/publ/Headers/FBL_post_header.h>

#endif // _FBL_MemPtr_h
